home *** CD-ROM | disk | FTP | other *** search
/ Atari Mega Archive 1 / Atari Mega Archive - Volume 1.iso / tex / tex31 / texsrc.lzh / TEXSRC.LZH / tex14.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-11-28  |  23.3 KB  |  1,018 lines
  1. #define EXTERN extern
  2. #include "texd.h"
  3.  
  4. void starteqno ( ) 
  5. {starteqno_regmem 
  6.   savestack [ saveptr + 0 ] .cint = curchr ; 
  7.   incr ( saveptr ) ; 
  8.   {
  9.     pushmath ( 15 ) ; 
  10.     eqworddefine ( 6207 , -1 ) ; 
  11.     if ( eqtb [ 4315 ] .hh .v.RH != 0 ) 
  12.     begintokenlist ( eqtb [ 4315 ] .hh .v.RH , 8 ) ; 
  13.   } 
  14. } 
  15. void zscanmath ( p ) 
  16. halfword p ; 
  17. {/* 20 21 10 */ scanmath_regmem 
  18.   integer c  ; 
  19.   lab20: do {
  20.       getxtoken () ; 
  21.   } while ( ! ( ( curcmd != 10 ) && ( curcmd != 0 ) ) ) ; 
  22.   lab21: switch ( curcmd ) 
  23.   {case 11 : 
  24.   case 12 : 
  25.   case 68 : 
  26.     {
  27.       c = eqtb [ 5907 + curchr ] .hh .v.RH ; 
  28.       if ( c == 32768L ) 
  29.       {
  30.     {
  31.       curcs = curchr + 1 ; 
  32.       curcmd = eqtb [ curcs ] .hh.b0 ; 
  33.       curchr = eqtb [ curcs ] .hh .v.RH ; 
  34.       xtoken () ; 
  35.       backinput () ; 
  36.     } 
  37.     goto lab20 ; 
  38.       } 
  39.     } 
  40.     break ; 
  41.   case 16 : 
  42.     {
  43.       scancharnum () ; 
  44.       curchr = curval ; 
  45.       curcmd = 68 ; 
  46.       goto lab21 ; 
  47.     } 
  48.     break ; 
  49.   case 17 : 
  50.     {
  51.       scanfifteenbitint () ; 
  52.       c = curval ; 
  53.     } 
  54.     break ; 
  55.   case 69 : 
  56.     c = curchr ; 
  57.     break ; 
  58.   case 15 : 
  59.     {
  60.       scantwentysevenbitint () ; 
  61.       c = curval / 4096 ; 
  62.     } 
  63.     break ; 
  64.     default: 
  65.     {
  66.       backinput () ; 
  67.       scanleftbrace () ; 
  68.       savestack [ saveptr + 0 ] .cint = p ; 
  69.       incr ( saveptr ) ; 
  70.       pushmath ( 9 ) ; 
  71.       return ; 
  72.     } 
  73.     break ; 
  74.   } 
  75.   mem [ p ] .hh .v.RH = 1 ; 
  76.   mem [ p ] .hh.b1 = c % 256 ; 
  77.   if ( ( c >= 28672 ) && ( ( eqtb [ 6207 ] .cint >= 0 ) && ( eqtb [ 6207 ] 
  78.   .cint < 16 ) ) ) 
  79.   mem [ p ] .hh.b0 = eqtb [ 6207 ] .cint ; 
  80.   else mem [ p ] .hh.b0 = ( c / 256 ) % 16 ; 
  81. } 
  82. void zsetmathchar ( c ) 
  83. integer c ; 
  84. {setmathchar_regmem 
  85.   halfword p  ; 
  86.   if ( c >= 32768L ) 
  87.   {
  88.     curcs = curchr + 1 ; 
  89.     curcmd = eqtb [ curcs ] .hh.b0 ; 
  90.     curchr = eqtb [ curcs ] .hh .v.RH ; 
  91.     xtoken () ; 
  92.     backinput () ; 
  93.   } 
  94.   else {
  95.       
  96.     p = newnoad () ; 
  97.     mem [ p + 1 ] .hh .v.RH = 1 ; 
  98.     mem [ p + 1 ] .hh.b1 = c % 256 ; 
  99.     mem [ p + 1 ] .hh.b0 = ( c / 256 ) % 16 ; 
  100.     if ( c >= 28672 ) 
  101.     {
  102.       if ( ( ( eqtb [ 6207 ] .cint >= 0 ) && ( eqtb [ 6207 ] .cint < 16 ) ) ) 
  103.       mem [ p + 1 ] .hh.b0 = eqtb [ 6207 ] .cint ; 
  104.       mem [ p ] .hh.b0 = 16 ; 
  105.     } 
  106.     else mem [ p ] .hh.b0 = 16 + ( c / 4096 ) ; 
  107.     mem [ curlist .tailfield ] .hh .v.RH = p ; 
  108.     curlist .tailfield = p ; 
  109.   } 
  110. } 
  111. void mathlimitswitch ( ) 
  112. {/* 10 */ mathlimitswitch_regmem 
  113.   if ( curlist .headfield != curlist .tailfield ) 
  114.   if ( mem [ curlist .tailfield ] .hh.b0 == 17 ) 
  115.   {
  116.     mem [ curlist .tailfield ] .hh.b1 = curchr ; 
  117.     return ; 
  118.   } 
  119.   {
  120.     if ( interaction == 3 ) 
  121.     wakeupterminal () ; 
  122.     printnl ( 262 ) ; 
  123.     print ( 1123 ) ; 
  124.   } 
  125.   {
  126.     helpptr = 1 ; 
  127.     helpline [ 0 ] = 1124 ; 
  128.   } 
  129.   error () ; 
  130. } 
  131. void zscandelimiter ( p , r ) 
  132. halfword p ; 
  133. boolean r ; 
  134. {scandelimiter_regmem 
  135.   if ( r ) 
  136.   scantwentysevenbitint () ; 
  137.   else {
  138.       
  139.     do {
  140.     getxtoken () ; 
  141.     } while ( ! ( ( curcmd != 10 ) && ( curcmd != 0 ) ) ) ; 
  142.     switch ( curcmd ) 
  143.     {case 11 : 
  144.     case 12 : 
  145.       curval = eqtb [ 6474 + curchr ] .cint ; 
  146.       break ; 
  147.     case 15 : 
  148.       scantwentysevenbitint () ; 
  149.       break ; 
  150.       default: 
  151.       curval = -1 ; 
  152.       break ; 
  153.     } 
  154.   } 
  155.   if ( curval < 0 ) 
  156.   {
  157.     {
  158.       if ( interaction == 3 ) 
  159.       wakeupterminal () ; 
  160.       printnl ( 262 ) ; 
  161.       print ( 1125 ) ; 
  162.     } 
  163.     {
  164.       helpptr = 6 ; 
  165.       helpline [ 5 ] = 1126 ; 
  166.       helpline [ 4 ] = 1127 ; 
  167.       helpline [ 3 ] = 1128 ; 
  168.       helpline [ 2 ] = 1129 ; 
  169.       helpline [ 1 ] = 1130 ; 
  170.       helpline [ 0 ] = 1131 ; 
  171.     } 
  172.     backerror () ; 
  173.     curval = 0 ; 
  174.   } 
  175.   mem [ p ] .qqqq .b0 = ( curval / 1048576L ) % 16 ; 
  176.   mem [ p ] .qqqq .b1 = ( curval / 4096 ) % 256 ; 
  177.   mem [ p ] .qqqq .b2 = ( curval / 256 ) % 16 ; 
  178.   mem [ p ] .qqqq .b3 = curval % 256 ; 
  179. } 
  180. void mathradical ( ) 
  181. {mathradical_regmem 
  182.   {
  183.     mem [ curlist .tailfield ] .hh .v.RH = getnode ( 5 ) ; 
  184.     curlist .tailfield = mem [ curlist .tailfield ] .hh .v.RH ; 
  185.   } 
  186.   mem [ curlist .tailfield ] .hh.b0 = 24 ; 
  187.   mem [ curlist .tailfield ] .hh.b1 = 0 ; 
  188.   mem [ curlist .tailfield + 1 ] .hh = emptyfield ; 
  189.   mem [ curlist .tailfield + 3 ] .hh = emptyfield ; 
  190.   mem [ curlist .tailfield + 2 ] .hh = emptyfield ; 
  191.   scandelimiter ( curlist .tailfield + 4 , true ) ; 
  192.   scanmath ( curlist .tailfield + 1 ) ; 
  193. } 
  194. void mathac ( ) 
  195. {mathac_regmem 
  196.   if ( curcmd == 45 ) 
  197.   {
  198.     {
  199.       if ( interaction == 3 ) 
  200.       wakeupterminal () ; 
  201.       printnl ( 262 ) ; 
  202.       print ( 1132 ) ; 
  203.     } 
  204.     printesc ( 519 ) ; 
  205.     print ( 1133 ) ; 
  206.     {
  207.       helpptr = 2 ; 
  208.       helpline [ 1 ] = 1134 ; 
  209.       helpline [ 0 ] = 1135 ; 
  210.     } 
  211.     error () ; 
  212.   } 
  213.   {
  214.     mem [ curlist .tailfield ] .hh .v.RH = getnode ( 5 ) ; 
  215.     curlist .tailfield = mem [ curlist .tailfield ] .hh .v.RH ; 
  216.   } 
  217.   mem [ curlist .tailfield ] .hh.b0 = 28 ; 
  218.   mem [ curlist .tailfield ] .hh.b1 = 0 ; 
  219.   mem [ curlist .tailfield + 1 ] .hh = emptyfield ; 
  220.   mem [ curlist .tailfield + 3 ] .hh = emptyfield ; 
  221.   mem [ curlist .tailfield + 2 ] .hh = emptyfield ; 
  222.   mem [ curlist .tailfield + 4 ] .hh .v.RH = 1 ; 
  223.   scanfifteenbitint () ; 
  224.   mem [ curlist .tailfield + 4 ] .hh.b1 = curval % 256 ; 
  225.   if ( ( curval >= 28672 ) && ( ( eqtb [ 6207 ] .cint >= 0 ) && ( eqtb [ 6207 
  226.   ] .cint < 16 ) ) ) 
  227.   mem [ curlist .tailfield + 4 ] .hh.b0 = eqtb [ 6207 ] .cint ; 
  228.   else mem [ curlist .tailfield + 4 ] .hh.b0 = ( curval / 256 ) % 16 ; 
  229.   scanmath ( curlist .tailfield + 1 ) ; 
  230. } 
  231. void appendchoices ( ) 
  232. {appendchoices_regmem 
  233.   {
  234.     mem [ curlist .tailfield ] .hh .v.RH = newchoice () ; 
  235.     curlist .tailfield = mem [ curlist .tailfield ] .hh .v.RH ; 
  236.   } 
  237.   incr ( saveptr ) ; 
  238.   savestack [ saveptr - 1 ] .cint = 0 ; 
  239.   pushmath ( 13 ) ; 
  240.   scanleftbrace () ; 
  241. } 
  242. halfword zfinmlist ( p ) 
  243. halfword p ; 
  244. {register halfword Result; finmlist_regmem 
  245.   halfword q  ; 
  246.   if ( curlist .auxfield .cint != 0 ) 
  247.   {
  248.     mem [ curlist .auxfield .cint + 3 ] .hh .v.RH = 3 ; 
  249.     mem [ curlist .auxfield .cint + 3 ] .hh .v.LH = mem [ curlist .headfield ] 
  250.     .hh .v.RH ; 
  251.     if ( p == 0 ) 
  252.     q = curlist .auxfield .cint ; 
  253.     else {
  254.     
  255.       q = mem [ curlist .auxfield .cint + 2 ] .hh .v.LH ; 
  256.       if ( mem [ q ] .hh.b0 != 30 ) 
  257.       confusion ( 870 ) ; 
  258.       mem [ curlist .auxfield .cint + 2 ] .hh .v.LH = mem [ q ] .hh .v.RH ; 
  259.       mem [ q ] .hh .v.RH = curlist .auxfield .cint ; 
  260.       mem [ curlist .auxfield .cint ] .hh .v.RH = p ; 
  261.     } 
  262.   } 
  263.   else {
  264.       
  265.     mem [ curlist .tailfield ] .hh .v.RH = p ; 
  266.     q = mem [ curlist .headfield ] .hh .v.RH ; 
  267.   } 
  268.   popnest () ; 
  269.   Result = q ; 
  270.   return(Result) ; 
  271. } 
  272. void buildchoices ( ) 
  273. {/* 10 */ buildchoices_regmem 
  274.   halfword p  ; 
  275.   unsave () ; 
  276.   p = finmlist ( 0 ) ; 
  277.   switch ( savestack [ saveptr - 1 ] .cint ) 
  278.   {case 0 : 
  279.     mem [ curlist .tailfield + 1 ] .hh .v.LH = p ; 
  280.     break ; 
  281.   case 1 : 
  282.     mem [ curlist .tailfield + 1 ] .hh .v.RH = p ; 
  283.     break ; 
  284.   case 2 : 
  285.     mem [ curlist .tailfield + 2 ] .hh .v.LH = p ; 
  286.     break ; 
  287.   case 3 : 
  288.     {
  289.       mem [ curlist .tailfield + 2 ] .hh .v.RH = p ; 
  290.       decr ( saveptr ) ; 
  291.       return ; 
  292.     } 
  293.     break ; 
  294.   } 
  295.   incr ( savestack [ saveptr - 1 ] .cint ) ; 
  296.   pushmath ( 13 ) ; 
  297.   scanleftbrace () ; 
  298. } 
  299. void subsup ( ) 
  300. {subsup_regmem 
  301.   smallnumber t  ; 
  302.   halfword p  ; 
  303.   t = 0 ; 
  304.   p = 0 ; 
  305.   if ( curlist .tailfield != curlist .headfield ) 
  306.   if ( ( mem [ curlist .tailfield ] .hh.b0 >= 16 ) && ( mem [ curlist 
  307.   .tailfield ] .hh.b0 < 30 ) ) 
  308.   {
  309.     p = curlist .tailfield + 2 + curcmd - 7 ; 
  310.     t = mem [ p ] .hh .v.RH ; 
  311.   } 
  312.   if ( ( p == 0 ) || ( t != 0 ) ) 
  313.   {
  314.     {
  315.       mem [ curlist .tailfield ] .hh .v.RH = newnoad () ; 
  316.       curlist .tailfield = mem [ curlist .tailfield ] .hh .v.RH ; 
  317.     } 
  318.     p = curlist .tailfield + 2 + curcmd - 7 ; 
  319.     if ( t != 0 ) 
  320.     {
  321.       if ( curcmd == 7 ) 
  322.       {
  323.     {
  324.       if ( interaction == 3 ) 
  325.       wakeupterminal () ; 
  326.       printnl ( 262 ) ; 
  327.       print ( 1136 ) ; 
  328.     } 
  329.     {
  330.       helpptr = 1 ; 
  331.       helpline [ 0 ] = 1137 ; 
  332.     } 
  333.       } 
  334.       else {
  335.       
  336.     {
  337.       if ( interaction == 3 ) 
  338.       wakeupterminal () ; 
  339.       printnl ( 262 ) ; 
  340.       print ( 1138 ) ; 
  341.     } 
  342.     {
  343.       helpptr = 1 ; 
  344.       helpline [ 0 ] = 1139 ; 
  345.     } 
  346.       } 
  347.       error () ; 
  348.     } 
  349.   } 
  350.   scanmath ( p ) ; 
  351. } 
  352. void mathfraction ( ) 
  353. {mathfraction_regmem 
  354.   smallnumber c  ; 
  355.   c = curchr ; 
  356.   if ( curlist .auxfield .cint != 0 ) 
  357.   {
  358.     if ( c >= 3 ) 
  359.     {
  360.       scandelimiter ( memtop - 12 , false ) ; 
  361.       scandelimiter ( memtop - 12 , false ) ; 
  362.     } 
  363.     if ( c % 3 == 0 ) 
  364.     scandimen ( false , false , false ) ; 
  365.     {
  366.       if ( interaction == 3 ) 
  367.       wakeupterminal () ; 
  368.       printnl ( 262 ) ; 
  369.       print ( 1146 ) ; 
  370.     } 
  371.     {
  372.       helpptr = 3 ; 
  373.       helpline [ 2 ] = 1147 ; 
  374.       helpline [ 1 ] = 1148 ; 
  375.       helpline [ 0 ] = 1149 ; 
  376.     } 
  377.     error () ; 
  378.   } 
  379.   else {
  380.       
  381.     curlist .auxfield .cint = getnode ( 6 ) ; 
  382.     mem [ curlist .auxfield .cint ] .hh.b0 = 25 ; 
  383.     mem [ curlist .auxfield .cint ] .hh.b1 = 0 ; 
  384.     mem [ curlist .auxfield .cint + 2 ] .hh .v.RH = 3 ; 
  385.     mem [ curlist .auxfield .cint + 2 ] .hh .v.LH = mem [ curlist .headfield ] 
  386.     .hh .v.RH ; 
  387.     mem [ curlist .auxfield .cint + 3 ] .hh = emptyfield ; 
  388.     mem [ curlist .auxfield .cint + 4 ] .qqqq = nulldelimiter ; 
  389.     mem [ curlist .auxfield .cint + 5 ] .qqqq = nulldelimiter ; 
  390.     mem [ curlist .headfield ] .hh .v.RH = 0 ; 
  391.     curlist .tailfield = curlist .headfield ; 
  392.     if ( c >= 3 ) 
  393.     {
  394.       scandelimiter ( curlist .auxfield .cint + 4 , false ) ; 
  395.       scandelimiter ( curlist .auxfield .cint + 5 , false ) ; 
  396.     } 
  397.     switch ( c % 3 ) 
  398.     {case 0 : 
  399.       {
  400.     scandimen ( false , false , false ) ; 
  401.     mem [ curlist .auxfield .cint + 1 ] .cint = curval ; 
  402.       } 
  403.       break ; 
  404.     case 1 : 
  405.       mem [ curlist .auxfield .cint + 1 ] .cint = 1073741824L ; 
  406.       break ; 
  407.     case 2 : 
  408.       mem [ curlist .auxfield .cint + 1 ] .cint = 0 ; 
  409.       break ; 
  410.     } 
  411.   } 
  412. } 
  413. void mathleftright ( ) 
  414. {mathleftright_regmem 
  415.   smallnumber t  ; 
  416.   halfword p  ; 
  417.   t = curchr ; 
  418.   if ( ( t == 31 ) && ( curgroup != 16 ) ) 
  419.   {
  420.     if ( curgroup == 15 ) 
  421.     {
  422.       scandelimiter ( memtop - 12 , false ) ; 
  423.       {
  424.     if ( interaction == 3 ) 
  425.     wakeupterminal () ; 
  426.     printnl ( 262 ) ; 
  427.     print ( 772 ) ; 
  428.       } 
  429.       printesc ( 870 ) ; 
  430.       {
  431.     helpptr = 1 ; 
  432.     helpline [ 0 ] = 1150 ; 
  433.       } 
  434.       error () ; 
  435.     } 
  436.     else offsave () ; 
  437.   } 
  438.   else {
  439.       
  440.     p = newnoad () ; 
  441.     mem [ p ] .hh.b0 = t ; 
  442.     scandelimiter ( p + 1 , false ) ; 
  443.     if ( t == 30 ) 
  444.     {
  445.       pushmath ( 16 ) ; 
  446.       mem [ curlist .headfield ] .hh .v.RH = p ; 
  447.       curlist .tailfield = p ; 
  448.     } 
  449.     else {
  450.     
  451.       p = finmlist ( p ) ; 
  452.       unsave () ; 
  453.       {
  454.     mem [ curlist .tailfield ] .hh .v.RH = newnoad () ; 
  455.     curlist .tailfield = mem [ curlist .tailfield ] .hh .v.RH ; 
  456.       } 
  457.       mem [ curlist .tailfield ] .hh.b0 = 23 ; 
  458.       mem [ curlist .tailfield + 1 ] .hh .v.RH = 3 ; 
  459.       mem [ curlist .tailfield + 1 ] .hh .v.LH = p ; 
  460.     } 
  461.   } 
  462. } 
  463. void aftermath ( ) 
  464. {aftermath_regmem 
  465.   boolean l  ; 
  466.   boolean danger  ; 
  467.   integer m  ; 
  468.   halfword p  ; 
  469.   halfword a  ; 
  470.   halfword b  ; 
  471.   scaled w  ; 
  472.   scaled z  ; 
  473.   scaled e  ; 
  474.   scaled q  ; 
  475.   scaled d  ; 
  476.   scaled s  ; 
  477.   smallnumber g1, g2  ; 
  478.   halfword r  ; 
  479.   halfword t  ; 
  480.   danger = false ; 
  481.   if ( ( fontparams [ eqtb [ 4837 ] .hh .v.RH ] < 22 ) || ( fontparams [ eqtb 
  482.   [ 4853 ] .hh .v.RH ] < 22 ) || ( fontparams [ eqtb [ 4869 ] .hh .v.RH ] < 22 
  483.   ) ) 
  484.   {
  485.     {
  486.       if ( interaction == 3 ) 
  487.       wakeupterminal () ; 
  488.       printnl ( 262 ) ; 
  489.       print ( 1151 ) ; 
  490.     } 
  491.     {
  492.       helpptr = 3 ; 
  493.       helpline [ 2 ] = 1152 ; 
  494.       helpline [ 1 ] = 1153 ; 
  495.       helpline [ 0 ] = 1154 ; 
  496.     } 
  497.     error () ; 
  498.     flushmath () ; 
  499.     danger = true ; 
  500.   } 
  501.   else if ( ( fontparams [ eqtb [ 4838 ] .hh .v.RH ] < 13 ) || ( fontparams [ 
  502.   eqtb [ 4854 ] .hh .v.RH ] < 13 ) || ( fontparams [ eqtb [ 4870 ] .hh .v.RH ] 
  503.   < 13 ) ) 
  504.   {
  505.     {
  506.       if ( interaction == 3 ) 
  507.       wakeupterminal () ; 
  508.       printnl ( 262 ) ; 
  509.       print ( 1155 ) ; 
  510.     } 
  511.     {
  512.       helpptr = 3 ; 
  513.       helpline [ 2 ] = 1156 ; 
  514.       helpline [ 1 ] = 1157 ; 
  515.       helpline [ 0 ] = 1158 ; 
  516.     } 
  517.     error () ; 
  518.     flushmath () ; 
  519.     danger = true ; 
  520.   } 
  521.   m = curlist .modefield ; 
  522.   l = false ; 
  523.   p = finmlist ( 0 ) ; 
  524.   if ( curlist .modefield == - (integer) m ) 
  525.   {
  526.     {
  527.       getxtoken () ; 
  528.       if ( curcmd != 3 ) 
  529.       {
  530.     {
  531.       if ( interaction == 3 ) 
  532.       wakeupterminal () ; 
  533.       printnl ( 262 ) ; 
  534.       print ( 1159 ) ; 
  535.     } 
  536.     {
  537.       helpptr = 2 ; 
  538.       helpline [ 1 ] = 1160 ; 
  539.       helpline [ 0 ] = 1161 ; 
  540.     } 
  541.     backerror () ; 
  542.       } 
  543.     } 
  544.     curmlist = p ; 
  545.     curstyle = 2 ; 
  546.     mlistpenalties = false ; 
  547.     mlisttohlist () ; 
  548.     a = hpack ( mem [ memtop - 3 ] .hh .v.RH , 0 , 1 ) ; 
  549.     unsave () ; 
  550.     decr ( saveptr ) ; 
  551.     if ( savestack [ saveptr + 0 ] .cint == 1 ) 
  552.     l = true ; 
  553.     danger = false ; 
  554.     if ( ( fontparams [ eqtb [ 4837 ] .hh .v.RH ] < 22 ) || ( fontparams [ 
  555.     eqtb [ 4853 ] .hh .v.RH ] < 22 ) || ( fontparams [ eqtb [ 4869 ] .hh .v.RH 
  556.     ] < 22 ) ) 
  557.     {
  558.       {
  559.     if ( interaction == 3 ) 
  560.     wakeupterminal () ; 
  561.     printnl ( 262 ) ; 
  562.     print ( 1151 ) ; 
  563.       } 
  564.       {
  565.     helpptr = 3 ; 
  566.     helpline [ 2 ] = 1152 ; 
  567.     helpline [ 1 ] = 1153 ; 
  568.     helpline [ 0 ] = 1154 ; 
  569.       } 
  570.       error () ; 
  571.       flushmath () ; 
  572.       danger = true ; 
  573.     } 
  574.     else if ( ( fontparams [ eqtb [ 4838 ] .hh .v.RH ] < 13 ) || ( fontparams 
  575.     [ eqtb [ 4854 ] .hh .v.RH ] < 13 ) || ( fontparams [ eqtb [ 4870 ] .hh 
  576.     .v.RH ] < 13 ) ) 
  577.     {
  578.       {
  579.     if ( interaction == 3 ) 
  580.     wakeupterminal () ; 
  581.     printnl ( 262 ) ; 
  582.     print ( 1155 ) ; 
  583.       } 
  584.       {
  585.     helpptr = 3 ; 
  586.     helpline [ 2 ] = 1156 ; 
  587.     helpline [ 1 ] = 1157 ; 
  588.     helpline [ 0 ] = 1158 ; 
  589.       } 
  590.       error () ; 
  591.       flushmath () ; 
  592.       danger = true ; 
  593.     } 
  594.     m = curlist .modefield ; 
  595.     p = finmlist ( 0 ) ; 
  596.   } 
  597.   else a = 0 ; 
  598.   if ( m < 0 ) 
  599.   {
  600.     {
  601.       mem [ curlist .tailfield ] .hh .v.RH = newmath ( eqtb [ 6731 ] .cint , 0 
  602.       ) ; 
  603.       curlist .tailfield = mem [ curlist .tailfield ] .hh .v.RH ; 
  604.     } 
  605.     curmlist = p ; 
  606.     curstyle = 2 ; 
  607.     mlistpenalties = ( curlist .modefield > 0 ) ; 
  608.     mlisttohlist () ; 
  609.     mem [ curlist .tailfield ] .hh .v.RH = mem [ memtop - 3 ] .hh .v.RH ; 
  610.     while ( mem [ curlist .tailfield ] .hh .v.RH != 0 ) curlist .tailfield = 
  611.     mem [ curlist .tailfield ] .hh .v.RH ; 
  612.     {
  613.       mem [ curlist .tailfield ] .hh .v.RH = newmath ( eqtb [ 6731 ] .cint , 1 
  614.       ) ; 
  615.       curlist .tailfield = mem [ curlist .tailfield ] .hh .v.RH ; 
  616.     } 
  617.     curlist .auxfield .hh .v.LH = 1000 ; 
  618.     unsave () ; 
  619.   } 
  620.   else {
  621.       
  622.     if ( a == 0 ) 
  623.     {
  624.       getxtoken () ; 
  625.       if ( curcmd != 3 ) 
  626.       {
  627.     {
  628.       if ( interaction == 3 ) 
  629.       wakeupterminal () ; 
  630.       printnl ( 262 ) ; 
  631.       print ( 1159 ) ; 
  632.     } 
  633.     {
  634.       helpptr = 2 ; 
  635.       helpline [ 1 ] = 1160 ; 
  636.       helpline [ 0 ] = 1161 ; 
  637.     } 
  638.     backerror () ; 
  639.       } 
  640.     } 
  641.     curmlist = p ; 
  642.     curstyle = 0 ; 
  643.     mlistpenalties = false ; 
  644.     mlisttohlist () ; 
  645.     p = mem [ memtop - 3 ] .hh .v.RH ; 
  646.     adjusttail = memtop - 5 ; 
  647.     b = hpack ( p , 0 , 1 ) ; 
  648.     p = mem [ b + 5 ] .hh .v.RH ; 
  649.     t = adjusttail ; 
  650.     adjusttail = 0 ; 
  651.     w = mem [ b + 1 ] .cint ; 
  652.     z = eqtb [ 6744 ] .cint ; 
  653.     s = eqtb [ 6745 ] .cint ; 
  654.     if ( ( a == 0 ) || danger ) 
  655.     {
  656.       e = 0 ; 
  657.       q = 0 ; 
  658.     } 
  659.     else {
  660.     
  661.       e = mem [ a + 1 ] .cint ; 
  662.       q = e + fontinfo [ 6 + parambase [ eqtb [ 4837 ] .hh .v.RH ] ] .cint ; 
  663.     } 
  664.     if ( w + q > z ) 
  665.     {
  666.       if ( ( e != 0 ) && ( ( w - totalshrink [ 0 ] + q <= z ) || ( totalshrink 
  667.       [ 1 ] != 0 ) || ( totalshrink [ 2 ] != 0 ) || ( totalshrink [ 3 ] != 0 ) 
  668.       ) ) 
  669.       {
  670.     freenode ( b , 7 ) ; 
  671.     b = hpack ( p , z - q , 0 ) ; 
  672.       } 
  673.       else {
  674.       
  675.     e = 0 ; 
  676.     if ( w > z ) 
  677.     {
  678.       freenode ( b , 7 ) ; 
  679.       b = hpack ( p , z , 0 ) ; 
  680.     } 
  681.       } 
  682.       w = mem [ b + 1 ] .cint ; 
  683.     } 
  684.     d = half ( z - w ) ; 
  685.     if ( ( e > 0 ) && ( d < 2 * e ) ) 
  686.     {
  687.       d = half ( z - w - e ) ; 
  688.       if ( p != 0 ) 
  689.       if ( ! ( p >= himemmin ) ) 
  690.       if ( mem [ p ] .hh.b0 == 10 ) 
  691.       d = 0 ; 
  692.     } 
  693.     {
  694.       mem [ curlist .tailfield ] .hh .v.RH = newpenalty ( eqtb [ 6174 ] .cint 
  695.       ) ; 
  696.       curlist .tailfield = mem [ curlist .tailfield ] .hh .v.RH ; 
  697.     } 
  698.     if ( ( d + s <= eqtb [ 6743 ] .cint ) || l ) 
  699.     {
  700.       g1 = 3 ; 
  701.       g2 = 4 ; 
  702.     } 
  703.     else {
  704.     
  705.       g1 = 5 ; 
  706.       g2 = 6 ; 
  707.     } 
  708.     if ( l && ( e == 0 ) ) 
  709.     {
  710.       mem [ a + 4 ] .cint = s ; 
  711.       appendtovlist ( a ) ; 
  712.       {
  713.     mem [ curlist .tailfield ] .hh .v.RH = newpenalty ( 10000 ) ; 
  714.     curlist .tailfield = mem [ curlist .tailfield ] .hh .v.RH ; 
  715.       } 
  716.     } 
  717.     else {
  718.     
  719.       mem [ curlist .tailfield ] .hh .v.RH = newparamglue ( g1 ) ; 
  720.       curlist .tailfield = mem [ curlist .tailfield ] .hh .v.RH ; 
  721.     } 
  722.     if ( e != 0 ) 
  723.     {
  724.       r = newkern ( z - w - e - d ) ; 
  725.       if ( l ) 
  726.       {
  727.     mem [ a ] .hh .v.RH = r ; 
  728.     mem [ r ] .hh .v.RH = b ; 
  729.     b = a ; 
  730.     d = 0 ; 
  731.       } 
  732.       else {
  733.       
  734.     mem [ b ] .hh .v.RH = r ; 
  735.     mem [ r ] .hh .v.RH = a ; 
  736.       } 
  737.       b = hpack ( b , 0 , 1 ) ; 
  738.     } 
  739.     mem [ b + 4 ] .cint = s + d ; 
  740.     appendtovlist ( b ) ; 
  741.     if ( ( a != 0 ) && ( e == 0 ) && ! l ) 
  742.     {
  743.       {
  744.     mem [ curlist .tailfield ] .hh .v.RH = newpenalty ( 10000 ) ; 
  745.     curlist .tailfield = mem [ curlist .tailfield ] .hh .v.RH ; 
  746.       } 
  747.       mem [ a + 4 ] .cint = s + z - mem [ a + 1 ] .cint ; 
  748.       appendtovlist ( a ) ; 
  749.       g2 = 0 ; 
  750.     } 
  751.     if ( t != memtop - 5 ) 
  752.     {
  753.       mem [ curlist .tailfield ] .hh .v.RH = mem [ memtop - 5 ] .hh .v.RH ; 
  754.       curlist .tailfield = t ; 
  755.     } 
  756.     {
  757.       mem [ curlist .tailfield ] .hh .v.RH = newpenalty ( eqtb [ 6175 ] .cint 
  758.       ) ; 
  759.       curlist .tailfield = mem [ curlist .tailfield ] .hh .v.RH ; 
  760.     } 
  761.     if ( g2 > 0 ) 
  762.     {
  763.       mem [ curlist .tailfield ] .hh .v.RH = newparamglue ( g2 ) ; 
  764.       curlist .tailfield = mem [ curlist .tailfield ] .hh .v.RH ; 
  765.     } 
  766.     resumeafterdisplay () ; 
  767.   } 
  768. } 
  769. void resumeafterdisplay ( ) 
  770. {resumeafterdisplay_regmem 
  771.   if ( curgroup != 15 ) 
  772.   confusion ( 1162 ) ; 
  773.   unsave () ; 
  774.   curlist .pgfield = curlist .pgfield + 3 ; 
  775.   pushnest () ; 
  776.   curlist .modefield = 102 ; 
  777.   curlist .auxfield .hh .v.LH = 1000 ; 
  778.   curlist .auxfield .hh .v.RH = 0 ; 
  779.   {
  780.     getxtoken () ; 
  781.     if ( curcmd != 10 ) 
  782.     backinput () ; 
  783.   } 
  784.   if ( nestptr == 1 ) 
  785.   buildpage () ; 
  786. } 
  787. void getrtoken ( ) 
  788. {/* 20 */ getrtoken_regmem 
  789.   lab20: do {
  790.       gettoken () ; 
  791.   } while ( ! ( curtok != 2592 ) ) ; 
  792.   if ( ( curcs == 0 ) || ( curcs > 3514 ) ) 
  793.   {
  794.     {
  795.       if ( interaction == 3 ) 
  796.       wakeupterminal () ; 
  797.       printnl ( 262 ) ; 
  798.       print ( 1177 ) ; 
  799.     } 
  800.     {
  801.       helpptr = 5 ; 
  802.       helpline [ 4 ] = 1178 ; 
  803.       helpline [ 3 ] = 1179 ; 
  804.       helpline [ 2 ] = 1180 ; 
  805.       helpline [ 1 ] = 1181 ; 
  806.       helpline [ 0 ] = 1182 ; 
  807.     } 
  808.     if ( curcs == 0 ) 
  809.     backinput () ; 
  810.     curtok = 7609 ; 
  811.     inserror () ; 
  812.     goto lab20 ; 
  813.   } 
  814. } 
  815. void trapzeroglue ( ) 
  816. {trapzeroglue_regmem 
  817.   if ( ( mem [ curval + 1 ] .cint == 0 ) && ( mem [ curval + 2 ] .cint == 0 ) 
  818.   && ( mem [ curval + 3 ] .cint == 0 ) ) 
  819.   {
  820.     incr ( mem [ 0 ] .hh .v.RH ) ; 
  821.     deleteglueref ( curval ) ; 
  822.     curval = 0 ; 
  823.   } 
  824. } 
  825. void zdoregistercommand ( a ) 
  826. smallnumber a ; 
  827. {/* 40 10 */ doregistercommand_regmem 
  828.   halfword l, q, r, s  ; 
  829.   schar p  ; 
  830.   q = curcmd ; 
  831.   {
  832.     if ( q != 89 ) 
  833.     {
  834.       getxtoken () ; 
  835.       if ( ( curcmd >= 73 ) && ( curcmd <= 76 ) ) 
  836.       {
  837.     l = curchr ; 
  838.     p = curcmd - 73 ; 
  839.     goto lab40 ; 
  840.       } 
  841.       if ( curcmd != 89 ) 
  842.       {
  843.     {
  844.       if ( interaction == 3 ) 
  845.       wakeupterminal () ; 
  846.       printnl ( 262 ) ; 
  847.       print ( 681 ) ; 
  848.     } 
  849.     printcmdchr ( curcmd , curchr ) ; 
  850.     print ( 682 ) ; 
  851.     printcmdchr ( q , 0 ) ; 
  852.     {
  853.       helpptr = 1 ; 
  854.       helpline [ 0 ] = 1203 ; 
  855.     } 
  856.     error () ; 
  857.     return ; 
  858.       } 
  859.     } 
  860.     p = curchr ; 
  861.     scaneightbitint () ; 
  862.     switch ( p ) 
  863.     {case 0 : 
  864.       l = curval + 6218 ; 
  865.       break ; 
  866.     case 1 : 
  867.       l = curval + 6751 ; 
  868.       break ; 
  869.     case 2 : 
  870.       l = curval + 3800 ; 
  871.       break ; 
  872.     case 3 : 
  873.       l = curval + 4056 ; 
  874.       break ; 
  875.     } 
  876.   } 
  877.   lab40: ; 
  878.   if ( q == 89 ) 
  879.   scanoptionalequals () ; 
  880.   else if ( scankeyword ( 1199 ) ) 
  881.   ; 
  882.   aritherror = false ; 
  883.   if ( q < 91 ) 
  884.   if ( p < 2 ) 
  885.   {
  886.     if ( p == 0 ) 
  887.     scanint () ; 
  888.     else scandimen ( false , false , false ) ; 
  889.     if ( q == 90 ) 
  890.     curval = curval + eqtb [ l ] .cint ; 
  891.   } 
  892.   else {
  893.       
  894.     scanglue ( p ) ; 
  895.     if ( q == 90 ) 
  896.     {
  897.       q = newspec ( curval ) ; 
  898.       r = eqtb [ l ] .hh .v.RH ; 
  899.       deleteglueref ( curval ) ; 
  900.       mem [ q + 1 ] .cint = mem [ q + 1 ] .cint + mem [ r + 1 ] .cint ; 
  901.       if ( mem [ q + 2 ] .cint == 0 ) 
  902.       mem [ q ] .hh.b0 = 0 ; 
  903.       if ( mem [ q ] .hh.b0 == mem [ r ] .hh.b0 ) 
  904.       mem [ q + 2 ] .cint = mem [ q + 2 ] .cint + mem [ r + 2 ] .cint ; 
  905.       else if ( ( mem [ q ] .hh.b0 < mem [ r ] .hh.b0 ) && ( mem [ r + 2 ] 
  906.       .cint != 0 ) ) 
  907.       {
  908.     mem [ q + 2 ] .cint = mem [ r + 2 ] .cint ; 
  909.     mem [ q ] .hh.b0 = mem [ r ] .hh.b0 ; 
  910.       } 
  911.       if ( mem [ q + 3 ] .cint == 0 ) 
  912.       mem [ q ] .hh.b1 = 0 ; 
  913.       if ( mem [ q ] .hh.b1 == mem [ r ] .hh.b1 ) 
  914.       mem [ q + 3 ] .cint = mem [ q + 3 ] .cint + mem [ r + 3 ] .cint ; 
  915.       else if ( ( mem [ q ] .hh.b1 < mem [ r ] .hh.b1 ) && ( mem [ r + 3 ] 
  916.       .cint != 0 ) ) 
  917.       {
  918.     mem [ q + 3 ] .cint = mem [ r + 3 ] .cint ; 
  919.     mem [ q ] .hh.b1 = mem [ r ] .hh.b1 ; 
  920.       } 
  921.       curval = q ; 
  922.     } 
  923.   } 
  924.   else {
  925.       
  926.     scanint () ; 
  927.     if ( p < 2 ) 
  928.     if ( q == 91 ) 
  929.     if ( p == 0 ) 
  930.     curval = multandadd ( eqtb [ l ] .cint , curval , 0 , 2147483647L ) ; 
  931.     else curval = multandadd ( eqtb [ l ] .cint , curval , 0 , 1073741823L ) ; 
  932.     else curval = xovern ( eqtb [ l ] .cint , curval ) ; 
  933.     else {
  934.     
  935.       s = eqtb [ l ] .hh .v.RH ; 
  936.       r = newspec ( s ) ; 
  937.       if ( q == 91 ) 
  938.       {
  939.     mem [ r + 1 ] .cint = multandadd ( mem [ s + 1 ] .cint , curval , 0 , 
  940.     1073741823L ) ; 
  941.     mem [ r + 2 ] .cint = multandadd ( mem [ s + 2 ] .cint , curval , 0 , 
  942.     1073741823L ) ; 
  943.     mem [ r + 3 ] .cint = multandadd ( mem [ s + 3 ] .cint , curval , 0 , 
  944.     1073741823L ) ; 
  945.       } 
  946.       else {
  947.       
  948.     mem [ r + 1 ] .cint = xovern ( mem [ s + 1 ] .cint , curval ) ; 
  949.     mem [ r + 2 ] .cint = xovern ( mem [ s + 2 ] .cint , curval ) ; 
  950.     mem [ r + 3 ] .cint = xovern ( mem [ s + 3 ] .cint , curval ) ; 
  951.       } 
  952.       curval = r ; 
  953.     } 
  954.   } 
  955.   if ( aritherror ) 
  956.   {
  957.     {
  958.       if ( interaction == 3 ) 
  959.       wakeupterminal () ; 
  960.       printnl ( 262 ) ; 
  961.       print ( 1200 ) ; 
  962.     } 
  963.     {
  964.       helpptr = 2 ; 
  965.       helpline [ 1 ] = 1201 ; 
  966.       helpline [ 0 ] = 1202 ; 
  967.     } 
  968.     error () ; 
  969.     return ; 
  970.   } 
  971.   if ( p < 2 ) 
  972.   if ( ( a >= 4 ) ) 
  973.   geqworddefine ( l , curval ) ; 
  974.   else eqworddefine ( l , curval ) ; 
  975.   else {
  976.       
  977.     trapzeroglue () ; 
  978.     if ( ( a >= 4 ) ) 
  979.     geqdefine ( l , 117 , curval ) ; 
  980.     else eqdefine ( l , 117 , curval ) ; 
  981.   } 
  982. } 
  983. void alteraux ( ) 
  984. {alteraux_regmem 
  985.   halfword c  ; 
  986.   if ( curchr != abs ( curlist .modefield ) ) 
  987.   reportillegalcase () ; 
  988.   else {
  989.       
  990.     c = curchr ; 
  991.     scanoptionalequals () ; 
  992.     if ( c == 1 ) 
  993.     {
  994.       scandimen ( false , false , false ) ; 
  995.       curlist .auxfield .cint = curval ; 
  996.     } 
  997.     else {
  998.     
  999.       scanint () ; 
  1000.       if ( ( curval <= 0 ) || ( curval > 32767 ) ) 
  1001.       {
  1002.     {
  1003.       if ( interaction == 3 ) 
  1004.       wakeupterminal () ; 
  1005.       printnl ( 262 ) ; 
  1006.       print ( 1204 ) ; 
  1007.     } 
  1008.     {
  1009.       helpptr = 1 ; 
  1010.       helpline [ 0 ] = 1205 ; 
  1011.     } 
  1012.     interror ( curval ) ; 
  1013.       } 
  1014.       else curlist .auxfield .hh .v.LH = curval ; 
  1015.     } 
  1016.   } 
  1017. } 
  1018.